{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GAN手写数字生成实验\n",
    "* MNIST[数据下载](http://yann.lecun.com/exdb/mnist/)\n",
    "* GAN的一般结构如下图所示，使用MNIST图像作为数据； \n",
    "* 生成器使用随机向量来构造图像； \n",
    "* 当生成器通过训练学习时，它会弄清楚如何将这些随机向量映射到可识别的图像。\n",
    "\n",
    "![gan_arc](pic/gan_arc.png)\n",
    "\n",
    "* Discriminator 使用 sigmoid 作为输出函数；\n",
    "* 0 代表这个图片是 G 模型制造的；\n",
    "* 1 代表这个图片就是 MNIST 图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/usr/local/lib/python3.6/dist-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import pickle as pkl\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/MNIST_data/train-images-idx3-ubyte.gz\n",
      "Extracting data/MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Extracting data/MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting data/MNIST_data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets('data/MNIST_data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![GAN](pic/GAN.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立模型输入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_inputs(real_dim, z_dim):\n",
    "    inputs_real = tf.placeholder(tf.float32, (None, real_dim), name='input_real') \n",
    "    inputs_z = tf.placeholder(tf.float32, (None, z_dim), name='input_z')\n",
    "    \n",
    "    return inputs_real, inputs_z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 编写 G 模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(z, out_dim, n_units=128, reuse=False, alpha=0.01):\n",
    "    with tf.variable_scope('generator', reuse=reuse):\n",
    "        # Hidden layer\n",
    "        h1 = tf.layers.dense(z, n_units, activation=None)\n",
    "        # Leaky ReLU\n",
    "        h1 = tf.maximum(alpha * h1, h1)        \n",
    "        # Logits and tanh output\n",
    "        logits = tf.layers.dense(h1, out_dim, activation=None)\n",
    "        out = tf.tanh(logits)\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 编写 D 模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator(x, n_units=128, reuse=False, alpha=0.01):\n",
    "    with tf.variable_scope('discriminator', reuse=reuse):\n",
    "        # Hidden layer\n",
    "        h1 = tf.layers.dense(x, n_units, activation=None)\n",
    "        # Leaky ReLU\n",
    "        h1 = tf.maximum(alpha * h1, h1)\n",
    "        # Logits and sigmoid output\n",
    "        logits = tf.layers.dense(h1, 1, activation=None)\n",
    "        out = tf.sigmoid(logits)\n",
    "        \n",
    "        return out, logits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置超参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = 784\n",
    "z_size = 100\n",
    "g_hidden_size = 128\n",
    "d_hidden_size = 128\n",
    "alpha = 0.01\n",
    "smooth = 0.1\n",
    "learning_rate = 0.002\n",
    "batch_size = 100\n",
    "epochs = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-5-f43d8a1e1436>:4: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "input_real, input_z = model_inputs(input_size, z_size)\n",
    "g_model = generator(input_z, input_size)\n",
    "d_model_real, d_logits_real = discriminator(input_real)\n",
    "d_model_fake, d_logits_fake = discriminator(g_model, reuse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 计算模型 G 与模型 D 的误差值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/nn_impl.py:180: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    }
   ],
   "source": [
    "d_loss_real = tf.reduce_mean(\n",
    "                  tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real, \n",
    "                                                          labels=tf.ones_like(d_logits_real) * (1 - smooth)))\n",
    "d_loss_fake = tf.reduce_mean(\n",
    "                  tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, \n",
    "                                                          labels=tf.zeros_like(d_logits_real)))\n",
    "d_loss = d_loss_real + d_loss_fake\n",
    "\n",
    "g_loss = tf.reduce_mean(\n",
    "             tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,\n",
    "                                                     labels=tf.ones_like(d_logits_fake)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置优化方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "t_vars = tf.trainable_variables()\n",
    "g_vars = [var for var in t_vars if var.name.startswith('generator')]\n",
    "d_vars = [var for var in t_vars if var.name.startswith('discriminator')]\n",
    "\n",
    "d_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_vars)\n",
    "g_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_vars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 开始训练并保存最后模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir checkpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100... Discriminator Loss: 0.3546... Generator Loss: 4.1219\n",
      "Epoch 2/100... Discriminator Loss: 0.3990... Generator Loss: 3.1797\n",
      "Epoch 3/100... Discriminator Loss: 0.3700... Generator Loss: 3.6524\n",
      "Epoch 4/100... Discriminator Loss: 0.4315... Generator Loss: 2.8386\n",
      "Epoch 5/100... Discriminator Loss: 0.5434... Generator Loss: 2.3932\n",
      "Epoch 6/100... Discriminator Loss: 1.0089... Generator Loss: 3.6713\n",
      "Epoch 7/100... Discriminator Loss: 0.8658... Generator Loss: 2.6396\n",
      "Epoch 8/100... Discriminator Loss: 0.9997... Generator Loss: 1.7887\n",
      "Epoch 9/100... Discriminator Loss: 0.8967... Generator Loss: 2.2819\n",
      "Epoch 10/100... Discriminator Loss: 0.7417... Generator Loss: 1.7780\n",
      "Epoch 11/100... Discriminator Loss: 0.7236... Generator Loss: 3.0988\n",
      "Epoch 12/100... Discriminator Loss: 1.3685... Generator Loss: 2.7542\n",
      "Epoch 13/100... Discriminator Loss: 1.2744... Generator Loss: 3.2181\n",
      "Epoch 14/100... Discriminator Loss: 0.7075... Generator Loss: 4.4834\n",
      "Epoch 15/100... Discriminator Loss: 0.7823... Generator Loss: 2.4860\n",
      "Epoch 16/100... Discriminator Loss: 0.6906... Generator Loss: 2.4321\n",
      "Epoch 17/100... Discriminator Loss: 0.7590... Generator Loss: 2.4084\n",
      "Epoch 18/100... Discriminator Loss: 0.9083... Generator Loss: 2.0321\n",
      "Epoch 19/100... Discriminator Loss: 1.0174... Generator Loss: 2.9032\n",
      "Epoch 20/100... Discriminator Loss: 1.0414... Generator Loss: 2.2603\n",
      "Epoch 21/100... Discriminator Loss: 0.9587... Generator Loss: 2.1909\n",
      "Epoch 22/100... Discriminator Loss: 0.5841... Generator Loss: 3.0226\n",
      "Epoch 23/100... Discriminator Loss: 0.7385... Generator Loss: 2.8154\n",
      "Epoch 24/100... Discriminator Loss: 0.7614... Generator Loss: 2.4587\n",
      "Epoch 25/100... Discriminator Loss: 0.9839... Generator Loss: 1.5880\n",
      "Epoch 26/100... Discriminator Loss: 0.7590... Generator Loss: 2.0527\n",
      "Epoch 27/100... Discriminator Loss: 1.0635... Generator Loss: 2.7432\n",
      "Epoch 28/100... Discriminator Loss: 0.9169... Generator Loss: 2.2547\n",
      "Epoch 29/100... Discriminator Loss: 0.7933... Generator Loss: 2.5263\n",
      "Epoch 30/100... Discriminator Loss: 0.8280... Generator Loss: 3.2185\n",
      "Epoch 31/100... Discriminator Loss: 0.9175... Generator Loss: 2.2278\n",
      "Epoch 32/100... Discriminator Loss: 0.7687... Generator Loss: 2.4443\n",
      "Epoch 33/100... Discriminator Loss: 0.7520... Generator Loss: 2.7353\n",
      "Epoch 34/100... Discriminator Loss: 0.6670... Generator Loss: 3.0903\n",
      "Epoch 35/100... Discriminator Loss: 0.6202... Generator Loss: 3.5326\n",
      "Epoch 36/100... Discriminator Loss: 0.7025... Generator Loss: 2.9755\n",
      "Epoch 37/100... Discriminator Loss: 0.6979... Generator Loss: 2.4785\n",
      "Epoch 38/100... Discriminator Loss: 0.8342... Generator Loss: 2.6725\n",
      "Epoch 39/100... Discriminator Loss: 0.9671... Generator Loss: 2.3295\n",
      "Epoch 40/100... Discriminator Loss: 0.7463... Generator Loss: 2.2918\n",
      "Epoch 41/100... Discriminator Loss: 0.7043... Generator Loss: 2.8224\n",
      "Epoch 42/100... Discriminator Loss: 0.5936... Generator Loss: 2.6882\n",
      "Epoch 43/100... Discriminator Loss: 0.9240... Generator Loss: 1.9327\n",
      "Epoch 44/100... Discriminator Loss: 0.7247... Generator Loss: 2.1861\n",
      "Epoch 45/100... Discriminator Loss: 0.7580... Generator Loss: 2.6308\n",
      "Epoch 46/100... Discriminator Loss: 0.6669... Generator Loss: 2.8317\n",
      "Epoch 47/100... Discriminator Loss: 0.7738... Generator Loss: 2.8183\n",
      "Epoch 48/100... Discriminator Loss: 0.8813... Generator Loss: 2.0519\n",
      "Epoch 49/100... Discriminator Loss: 0.7436... Generator Loss: 2.3564\n",
      "Epoch 50/100... Discriminator Loss: 0.8700... Generator Loss: 2.4395\n",
      "Epoch 51/100... Discriminator Loss: 1.0453... Generator Loss: 2.1748\n",
      "Epoch 52/100... Discriminator Loss: 0.7724... Generator Loss: 2.1847\n",
      "Epoch 53/100... Discriminator Loss: 0.9770... Generator Loss: 2.7002\n",
      "Epoch 54/100... Discriminator Loss: 0.9055... Generator Loss: 2.4051\n",
      "Epoch 55/100... Discriminator Loss: 0.8949... Generator Loss: 1.6942\n",
      "Epoch 56/100... Discriminator Loss: 0.9740... Generator Loss: 1.8565\n",
      "Epoch 57/100... Discriminator Loss: 0.8919... Generator Loss: 2.2975\n",
      "Epoch 58/100... Discriminator Loss: 0.8997... Generator Loss: 2.6137\n",
      "Epoch 59/100... Discriminator Loss: 0.9093... Generator Loss: 2.0418\n",
      "Epoch 60/100... Discriminator Loss: 1.0200... Generator Loss: 1.4100\n",
      "Epoch 61/100... Discriminator Loss: 0.8988... Generator Loss: 2.2292\n",
      "Epoch 62/100... Discriminator Loss: 0.9179... Generator Loss: 2.0272\n",
      "Epoch 63/100... Discriminator Loss: 0.9925... Generator Loss: 1.7377\n",
      "Epoch 64/100... Discriminator Loss: 0.8835... Generator Loss: 1.8652\n",
      "Epoch 65/100... Discriminator Loss: 0.9710... Generator Loss: 1.4696\n",
      "Epoch 66/100... Discriminator Loss: 0.8509... Generator Loss: 2.0530\n",
      "Epoch 67/100... Discriminator Loss: 0.8304... Generator Loss: 2.0151\n",
      "Epoch 68/100... Discriminator Loss: 1.0173... Generator Loss: 1.8377\n",
      "Epoch 69/100... Discriminator Loss: 0.8900... Generator Loss: 2.1253\n",
      "Epoch 70/100... Discriminator Loss: 0.9276... Generator Loss: 2.3172\n",
      "Epoch 71/100... Discriminator Loss: 0.9346... Generator Loss: 1.8880\n",
      "Epoch 72/100... Discriminator Loss: 1.0879... Generator Loss: 2.0605\n",
      "Epoch 73/100... Discriminator Loss: 0.9858... Generator Loss: 1.6382\n",
      "Epoch 74/100... Discriminator Loss: 0.8880... Generator Loss: 2.4845\n",
      "Epoch 75/100... Discriminator Loss: 0.9465... Generator Loss: 1.7225\n",
      "Epoch 76/100... Discriminator Loss: 0.9605... Generator Loss: 2.1097\n",
      "Epoch 77/100... Discriminator Loss: 0.8851... Generator Loss: 1.8855\n",
      "Epoch 78/100... Discriminator Loss: 0.8913... Generator Loss: 2.1999\n",
      "Epoch 79/100... Discriminator Loss: 0.8061... Generator Loss: 1.8920\n",
      "Epoch 80/100... Discriminator Loss: 0.9452... Generator Loss: 2.0464\n",
      "Epoch 81/100... Discriminator Loss: 1.0011... Generator Loss: 1.4549\n",
      "Epoch 82/100... Discriminator Loss: 0.7974... Generator Loss: 2.0132\n",
      "Epoch 83/100... Discriminator Loss: 0.9244... Generator Loss: 2.0131\n",
      "Epoch 84/100... Discriminator Loss: 1.0106... Generator Loss: 1.6266\n",
      "Epoch 85/100... Discriminator Loss: 0.9351... Generator Loss: 1.6358\n",
      "Epoch 86/100... Discriminator Loss: 0.9807... Generator Loss: 1.7449\n",
      "Epoch 87/100... Discriminator Loss: 0.7964... Generator Loss: 2.1737\n",
      "Epoch 88/100... Discriminator Loss: 0.9666... Generator Loss: 2.0249\n",
      "Epoch 89/100... Discriminator Loss: 0.9067... Generator Loss: 1.8564\n",
      "Epoch 90/100... Discriminator Loss: 1.1882... Generator Loss: 1.2631\n",
      "Epoch 91/100... Discriminator Loss: 0.8465... Generator Loss: 1.8912\n",
      "Epoch 92/100... Discriminator Loss: 0.9448... Generator Loss: 2.0872\n",
      "Epoch 93/100... Discriminator Loss: 0.7787... Generator Loss: 2.1564\n",
      "Epoch 94/100... Discriminator Loss: 0.9217... Generator Loss: 1.6351\n",
      "Epoch 95/100... Discriminator Loss: 0.9465... Generator Loss: 1.9479\n",
      "Epoch 96/100... Discriminator Loss: 0.8830... Generator Loss: 2.0306\n",
      "Epoch 97/100... Discriminator Loss: 1.0278... Generator Loss: 1.9626\n",
      "Epoch 98/100... Discriminator Loss: 0.8533... Generator Loss: 1.7725\n",
      "Epoch 99/100... Discriminator Loss: 0.8384... Generator Loss: 2.1499\n",
      "Epoch 100/100... Discriminator Loss: 0.8791... Generator Loss: 2.0471\n"
     ]
    }
   ],
   "source": [
    "samples = []\n",
    "losses = []\n",
    "# 只保存模型 G 的参数\n",
    "saver = tf.train.Saver(var_list=g_vars)\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    for e in range(epochs):\n",
    "        for ii in range(mnist.train.num_examples//batch_size):\n",
    "            batch = mnist.train.next_batch(batch_size)\n",
    "            \n",
    "            # 准备好给模型 D 的数据\n",
    "            batch_images = batch[0].reshape((batch_size, 784))\n",
    "            batch_images = batch_images*2 - 1\n",
    "            \n",
    "            # 初始化给模型 G 的噪声\n",
    "            batch_z = np.random.uniform(-1, 1, size=(batch_size, z_size))\n",
    "            \n",
    "            # 开始训练\n",
    "            _ = sess.run(d_train_opt, feed_dict={input_real: batch_images, input_z: batch_z})\n",
    "            _ = sess.run(g_train_opt, feed_dict={input_z: batch_z})\n",
    "        \n",
    "        # 每次迭代完成后输出 loss 并记录下来\n",
    "        train_loss_d = sess.run(d_loss, {input_z: batch_z, input_real: batch_images})\n",
    "        train_loss_g = g_loss.eval({input_z: batch_z})\n",
    "            \n",
    "        print(\"Epoch {}/{}...\".format(e+1, epochs),\n",
    "              \"Discriminator Loss: {:.4f}...\".format(train_loss_d),\n",
    "              \"Generator Loss: {:.4f}\".format(train_loss_g))    \n",
    "        losses.append((train_loss_d, train_loss_g))\n",
    "        \n",
    "        # 获取一些生成实例\n",
    "        sample_z = np.random.uniform(-1, 1, size=(16, z_size))\n",
    "        gen_samples = sess.run(\n",
    "                       generator(input_z, input_size, reuse=True),\n",
    "                       feed_dict={input_z: sample_z})\n",
    "        samples.append(gen_samples)\n",
    "        saver.save(sess, './checkpoints/generator.ckpt')\n",
    "\n",
    "# 保存实例文件\n",
    "with open('train_samples.pkl', 'wb') as f:\n",
    "    pkl.dump(samples, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss 绘图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f0e583518>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f39b0cc18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "losses = np.array(losses)\n",
    "plt.plot(losses.T[0], label='Discriminator')\n",
    "plt.plot(losses.T[1], label='Generator')\n",
    "plt.title(\"Training Losses\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 展示训练过程中保存下来的实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def view_samples(epoch, samples):\n",
    "    fig, axes = plt.subplots(figsize=(7,7), nrows=4, ncols=4, sharey=True, sharex=True)\n",
    "    for ax, img in zip(axes.flatten(), samples[epoch]):\n",
    "        ax.xaxis.set_visible(False)\n",
    "        ax.yaxis.set_visible(False)\n",
    "        im = ax.imshow(img.reshape((28,28)), cmap='Greys_r')\n",
    "    \n",
    "    return fig, axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开保存好的文件\n",
    "with open('train_samples.pkl', 'rb') as f:\n",
    "    samples = pkl.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0ed71f28>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘图展示最后的部分生成图片\n",
    "_ = view_samples(-1, samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f39aa0a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 展示更多训练过程\n",
    "rows, cols = 10, 6\n",
    "fig, axes = plt.subplots(figsize=(7,12), nrows=rows, ncols=cols, sharex=True, sharey=True)\n",
    "\n",
    "for sample, ax_row in zip(samples[::int(len(samples)/rows)], axes):\n",
    "    for img, ax in zip(sample[::int(len(sample)/cols)], ax_row):\n",
    "        ax.imshow(img.reshape((28,28)), cmap='Greys_r')\n",
    "        ax.xaxis.set_visible(False)\n",
    "        ax.yaxis.set_visible(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 利用存档点和新鲜噪声生成新图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from checkpoints/generator.ckpt\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAGRCAYAAABR3wXnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJztvXeYFFX6vn/GgJLRAVHiiBIFUUFQ1BUxZ1wjKu6aw4JpRTHHVUE/qKhrXAUMoCgq5gyKIgomVBQli0QTQczz++P3rdd7tA5dNd19pnt47uvqy8eiuup0nao+c55+3/eUlJeXOyGEECLfrFXVDRBCCLFmoAFHCCFEEDTgCCGECIIGHCGEEEHQgCOEECIIGnCEEEIEQQOOEEKIIGjAEUIIEQQNOEIIIcJQXl6e+FVaWlrunNMrR68uXbqUO+eWpOmDbPqlRo0a9qrqz15SUmKvqm5LPvqltLQ0Ok5RX4sCewV7VvRK9kr7rKSa4ZSVlaXZXWRg8uTJzjk3J9vjJO2XJk2a2KuqWW+99exVaOSiX8rKyqLjZGSdddaxl1gtwZ4VkYy0z4osNSGEEEEoyj+p1l13XdO//PJLFbakcNh0001Nz5o1K3af2bNnB2pNZn788ceqbkLBoHtYrClohiOEECIIGnCEEEIEoSgtNVkQf8Vno+WbWrVqmf7hhx+qpA3FSElJiWmtSSXWFDTDEUIIEQQNOEIIIYIQ1FJbU22E5s2bm543b14VtiT3yEarHEnu/zX1eRHVF81whBBCBEEDjhBCiCBkZamlTcCsCltgww03NP3II4+YHj9+vOnLL788r20oRBuNfffrr7+aZh+tv/76ppWoGR7ZaMVP3bp1TS9fvjx2nxEjRpg+9thjnXPO/fbbb/ltWBWhGY4QQoggaMARQggRhKwstZAJmGkidmrUqGGa9cNWrFhhul27dqavueYa0z///HM2zYxlrbX+GNd///33nB+/MiTpu2xstNtuu830aaed5pyTRVQMUWe8V9lGWrDch9bPkUceaXr48OGVbkMhX6ckzzL32WeffUyPGjUq4/H79u272n/n9WDV94ULF2Y8diGgGY4QQoggaMARQggRhIKupZZkas2y/N9//71zzrn58+fbNkZa1alTx/TMmTNN0y5IYqnVr1//L+dcHYVio+UDfjb2F4nqrR133HGx+/bp08f0yJEjTTN6rjpQaPZQ1Af16tWzbUcffbRpJiwz2vMf//iH6a+//tr0Oeec85djO5f+cxfadSK+Z9n3eZPYaGngefg9N2zYMNOnnHJK7HsLoQalZjhCCCGCoAFHCCFEEArOUqPtxaiyzTbbzDQjz5hM1aVLl9Uem9PRVq1amaalwCkzI3A6dOhgevTo0aZpNVxxxRWmb7rpptW2pZBIm8D7/9Yxd875bTQSWWZnnXWWbSstLTVds2ZN059++qnp1q1bmy5kmyVfrL322qazSQT02T3Rs0YbjbZY48aNTdOaJuzHsrIy0+us88dXSyFYOflg7Nixpvfbbz/TSZ6JXMBoONrVxxxzjGk+24WAZjhCCCGCoAFHCCFEEPJiqfmm8EkiV2ijcf/Fixebpu3F/SMLIsk0ctWqVaYZjcPtvXv3Nk3bgfbeTz/9ZPqNN97IeN6qxGdXprU8unfvbppRfb6kwY4dOzrnnKtdu7ZtoxV5+OGHm2YCG/dhNNSaQq7qafnq40XRg7yH77jjDtNnn3127Pv4XPK93377renqFmEYQSt+zz33NE1b3lczzUfbtm1NT58+3TlX8RrvtddepseMGWPaZ3PSzmzfvr3padOmxe7PSN98rxysGY4QQoggaMARQggRhLxYaj67LG2kEaeajF4irPc1adIk51xF+4W2zKOPPmr6iCOOyHh+JlNFU90/t4t2XKHjsyvT9gttFNpohMePbLcFCxbYNi7ZcPDBB8ce75tvvknVLrLVVluZfv/99yt9nOoArVTaMFG/cNkO2qsDBgwwTRubfUQL9KGHHjJdXaMKGQHGa7lkyRLT22+/vemJEyfGHodRr/xuiTs2k0fXW28900w6ZzI6r32SfuCzSDsuH7aoZjhCCCGCoAFHCCFEEIJGqaXls88+S7V/s2bNnHMVp7T9+/c3ffHFF1e6LYz2eP7552P3KeSy6s5lN11Om0DGzz9nzpy/bCObb7656VtuucX0dtttl+qcpJhstAYNGpj+7rvvcnJMLtGx0047meZKtzvvvPNftp100kmx7fItScCotmws0GLhsssui91Oa51RnLyGr7zyimlfxFhkjR1//PG2jc8tYWTcV199Zbphw4amv/jii9j3EvZtPpZnqXCuvB5dCCGE+H9owBFCCBGEoFFqaWEtKVpAtK5YhyuaVj722GO27cADD4w9RlqY1Dl37tzYfQrFRttoo41MM2E2m8/P6CVfZFom+D5G4Tz44IOm2V9rCrmy0QgTFFnX79lnnzUd1U3r3LmzbRs8eLBpX00wRqwNGTIk+8ZWA5gwPm7cuNh9GI3ZokUL04xSi7PP+Nx88MEHpnfddVfTW2yxhekpU6aYbtSokWlGiZJ822hEMxwhhBBB0IAjhBAiCAWxPAFtMU5NfRYQrSvuP2jQIOecc1OnTrVtXJ3wxhtvrHQbmXjqS0ItFGijVRVcjTCyjBi9M3DgQNNRdKFzzn300UemaamKdLRp08b0okWLTNNu7tWrl3POuccff9y2+aIR+cxxmYl828i0k4p95Vwuq8LoWdpocfc8r/Hpp59umjXbuEwEk57ffPPNyjc4D2iGI4QQIggacIQQQgShICw11kNLCy2AKCFz4403tm1333135RsmYvEtOUFok0XcdtttprfddlvTtFRJ2pVIC5GqsoSY/HfeeeeZvv32201H9bx81iX7+cknn4w9Rr4pdhvNBxOchw4dutp92Q9NmjQxfckll5hm3TvWW+vUqZNp2tVVhWY4QgghglBlM5xc/eXH0hHRQkJ169atfMOKlJBldfgX8XPPPWd6xx13NM3SKlFV29133922ReVunKu4MBsplLymbKiqv9Dvvfde02PHjjXdunVr05l+oN5mm21MM/+DP3LnapG4NQ1e51NPPdX08OHDnXMVK7KzL6N/d865jz/+2LTPDdhtt91Ma4YjhBBijUEDjhBCiCBUmaWWjdVAO+788883fcYZZzjnKsanX3311ZU+TzFRVfYT11snzAuI+ppWDH/89JErOyqJ3VjdbFh+zsMPP9w0qwrzx+WImTNnmqaNxuOFDODYYIMNTH/77bfBzhsS3udRBWjmTjGXkBW5aZW+9NJLpmmv7bPPPqZvvvlm01VlhWqGI4QQIggacIQQQgShIPJw0nLNNdeYjmw05/6wTlQSpWrgOu1HHnmk6agUSq1atVIdL1eWGtd791Vmpg1b3aAdtmTJEtORjcgqwswPKQSqq43WsmVL07TAMpWlYlkhwkrUY8aMMc3IUFqhtJBXrlyZoMW5QTMcIYQQQdCAI4QQIghBLTUm+KWdxnE98J49e5qOK61C6yZJhFJ1qkhblRx00EGmWQ03LhrKRz6m9/lY4CxbQibqNm/e3DSTCKOSNy+//HJezy/+f+68807TJ554oukddtjBdJp7gd+nfPZ85ab4PceSN6yun280wxFCCBEEDThCCCGCENRSy8YuYbXaLl26mI4SpQgXbmMl4vXXX990VN/LufxYGoyUW1PqTf3nP/8xHS2G51zFulCZOOWUU3LapqrGV+MqZKLuF198YfrDDz80HS3G1q5dO9s2YcIE09Whll0hwQRc3guVXSSNVfYZFcqfBWijMRqxadOmlTpntmiGI4QQIggacIQQQgShoBM/GW3BOkC0buJ47733TDdq1Mj0hhtuaHrWrFmmaa/5oDVHi2jLLbc0/f7775teU2w0H7Q1d9ppJ+ecc2+88UbG9z3++ON5a1NVUAgLx9FKXrp0qekoKbBOnTq2jc/OmmgL5xpeQy7Z0aNHj0odj8cYP368adYp9PHII4+Yvvbaa01zgb5826ia4QghhAiCBhwhhBBBqDJLzZf4RturcePGphmN5kskjKIzGA3SrFkz04zW8UWpjRgxwjTrOHEZhEsvvdT0ZZddFtsW8QesfRcHo2pWrFiRk3Puueeepp9//nnTG220kelMdauKGT5f2223nelNNtnE9Guvveacq7gq5JdffmlaNlr20FJllO7bb79tmrZbnKXFRPY+ffqY7t69e8bzR33sXMVkbN4fPD+t8HygGY4QQoggaMARQggRhCqz1HzRENy+//77m2YCE/eJO07r1q1NM9mJdaQOPPBA07R0WDa8TZs2pidPnmyaZfhFZnr16uWcc27VqlW2jdN49m2DBg1MZ1MDjTYaqc42GqPNzjzzTNNcNZPRllGkFJ+hhQsX5rOJawT77befaVpU7B9e8x9++MH0O++845yr+F3FiNq777474/lphbLeGr/n2rZta5qRi/leDkIzHCGEEEHQgCOEECIIBZf4yaiO4cOHx+5z4YUXmmYERzQ13WOPPWwbI9ZGjRplmlEa1EysYo0pRs/5EuJyZQdVN+KinWijEdo/uoaZ4f3Ke5T3Lm3lZcuWmY7qac2bNy+fTaxW8LuC3z2MrpwyZYpp1tLzwcTcKEk6+m9S+Kwwcnbo0KGmGembJNk9H2iGI4QQIggacIQQQgSh4Cw1Tk2pOTWlLcAp7kcffeScc27gwIG2jVPKTz75xDSnnYwS2X777U3Trthmm21MM2KNyAJaPbz+nTt3Ns3oma5du5pmdI6I5+effza98cYbm/70009NM2mZlnX0fB1xxBH5bGK1gtFlXCmVtuTWW28d+14uJ5BmFVwfjIArKyszffvtt5u+6aabTFeVjUY0wxFCCBEEDThCCCGCUHCWmg/aLocddpjpJk2amH700UedcxWnl5dcconpunXrpjon7QqfjSaSQxuN1gT7dvTo0RmPo7L58XB5jBtuuME0rRTabtG14/UUyWGNutNPPz12O2ufMRqNy3Bw2Y7rrrvuL+ehXceE3jFjxsS2i+csNDTDEUIIEQQNOEIIIYJQkmaFt65du5YzqUlkR3l5uSspKZlSXl7eNfPefirTL77lIULBczLaJkmiXL7JRb907dq1fPLkyRWuc0h43vbt25seNmyY6W7duoVsUi6okmclLVX9bIUk7bOiGY4QQoggaMARQggRhKKJUhO5paqn+kmspnXW+eP2zPdKhKHJd6Qd+5cJtzvssEPOz1VZqqv1xCVOZs+eXXUNKUA0wxFCCBEEDThCCCGCIEtNJIIrRXLlznxS3Ww0UlUJq6ylVtVUJxuNyEbzoxmOEEKIIGjAEUIIEYRUiZ8lJSVLnHNz8tecNZKW5eXljbI5gPolL2TVL+qTvKBnpTBJ3C+pBhwhhBCisshSE0IIEQQNOEIIIYKgAUcIIUQQNOAIIYQIggYcIYQQQdCAI4QQIggacIQQQgRBA44QQoggaMARQggRBA04QgghgqABRwghRBA04AghhAiCBhwhhBBB0IAjhBAiDOXl5YlfpaWl5c65jK+SkhJ7Jdk/1GuttdayV1W3xTlX3qVLl3Ln3JI0fZBNv+jlyps3b26vfPZLaWlpdBy9cvfSs1Jgr7TPyjouBWVlZe7rr7/OuN+6665r+ueff05zitSUlJSYzrS2z/rrr2/6hx9+yFubkjJ58mRXUlKS9WJQSfsl32Tqi7XXXtv077//Hrv9119/zXietdb6Y2LO4yThvPPOM92vX7/YfXLRL2VlZdFxsjmMqEi1eVaqC2mfFVlqQgghgpBqhpOUfM9qSJoVSwthVpMvsvmrf+ONNza9cOHCSrfB1xdR23777bfYf08yqyGTJk0yve2226Z6r29Ww1mWECI/aIYjhBAiCBpwhBBCBCEvllo+YCDCL7/8UoUtKUzS2mgkGxstCZVtW82aNU2vWrXKNG20NEEjq8Nn91UH0lyjddb54yuBViefv2bNmpmeNWtWkHaFoNDaUx3RDEcIIUQQNOAIIYQIQtFYarLRknPrrbea/te//mXaZ5e0bNnS9Jw5Wac6JCKJfUEbzUda66OYbJOePXuaHjduXOw+jK6rU6eO6e+//950ms/J+6Jhw4amly5danq99dZLfLzVUWjXvxDaEz2jSSI32d98VvJhD+fqudEMRwghRBA04AghhAhC0VhqaWASZOPGjU0zGmvLLbc03a5dO9OMqHryySdNc4qbNlExNIMGDYrd7mu3z0arUaOG6Vwn8/qm6BtttJFpliBhn9JePeCAA0yPHTs243mr0jZJa0v4bDRC+4Q2WpI2dO7c2Tnn3Pjx423b+++/b7pXr16xx/j0008znqdYyCZhOh9Ez2itWrVs2/Tp001vsskmptmXb7/9tunjjjvO9CeffJKTduXqudEMRwghRBA04AghhAhCUVpqnEp2797d9EcffeScqxiZ1aBBA9P77bef6Q4dOsQez2cdMWKI09ett97a9JQpU0zTjqKVla9pOz8DEyPnzp1b6WNmY6O1adPGNC2BOGhr8FrRLqJmtF0SG61QyJUt4bM6eQ/wmvLasQ2R3VKvXj3b9re//c1006ZNTWdzHxUyVWWjMcLsp59+Mh3Zxaz7uNtuu5meNm1a7PH4PbjLLruY5rOXzU8BilITQghRVGjAEUIIEYTUllraqI4kU7G0iYdNmjQxfc8995iOyuxzuko74bvvvovdzuQ5fr4lS5bEbq9fv75p2mgk5BINzlW8to8++mjQc0e89957pps3b246qr3FKCrfvfPCCy+YPvDAA2P3KfQowVzB+5L3q89G4z2QJPmPz0kc8+fPT9ROkZ6VK1eazmRR8fvO971FOnbsaDpXz4qi1IQQQhQVGnCEEEIEIbWl5rNCfFP7JFOxJBEwTEJ74oknTNeuXXu1bWSNIUb30C5jkhXfywQqJiTOnj3bNCNMCnFFUZ8FynLzV1xxhemjjjrK9Oabb26adbWeeuop01HyoHPOzZgxw3S3bt1MR8m3Rx55pG0bMWKEaV7//ffff7WfJylpo2q4f2h81lkSWywbq+PYY49d7b/TOv7mm28qfR6RHcuWLTPN55l9z0i2d955J3b/Qkhs1QxHCCFEEDTgCCGECELOEj85vUsyjVt//fVN//jjj7H7bLfddqYZjUYbjVEYUa001tp69dVXTd9///2x7WrUqJFp1l6j/uCDD0wvX77cdCHaaD58q6ZecMEFpml7MRpq8eLFpmmjcZ/DDjvMNG3HuGPQRiNJliRIAts4depU0+z3qqyr5rPRQhJFM15//fWx/04LWvyVbJIhM+3PY7M2ou+cV199tel99tnHNJ+zFStWpGpjPtAMRwghRBA04AghhAhCXmqp+Ww01sBidJePfv36mWZZbtpoixYtMn3VVVc55yqWWGftIVpKPD9rRrH2EBMVuVTBzjvvbDpKNnWu4vIHhQL7wheJNXLkSNNMwvXVOCO0XYYNG2a6b9++pqOaXW+++WbG9vrs1bQwCZVJdr5kx9D2WlXZaGSDDTZY7b8zOkr8lXzeM/zZYLPNNovdh3Z27969TRdyRKFmOEIIIYKgAUcIIUQQcmap+aInGI3js2W4T48ePUyzHhenj5dcconpu+66y3QUkcHoMlo+tGu22GIL04yYo80wceJE0w8//LBp1jb67LPPYj9Trsp5ZwvbQUuxa9eupo844ojY97JsPY9DO4jHHDNmjOloqQjnnCsrK3POObfVVltlbG82ZfBpl7GvuX3gwIGmBw8ebLoQkuJCQ9szjlzZm8XILbfcYprWfr6JEqzvvfde20ab2wcjQAsZzXCEEEIEQQOOEEKIIOQl8ZOkrQd10003me7UqZPpU0891fRDDz0Ue/woqoarfDIxkxYREwyPP/5408OHDzfdokWL2HaVlpaaptVUlfW4aBsxwYvXlsme7777rmmf/cflHGh10mphZBrro5188smmaXFmgiuopoV9vd5665lmHbxrr7220sevbsQlLaetg5iWQqvt5SOkjcbo3f79+zvnnNt3331j92WfjBs3znQhX0uiGY4QQoggaMARQggRhLwkfhKWqX/77bcz7l+3bl3Tn3/+uenXXnvNNC0dRrhFlhntsg033NA0p/NceoAWGVccZXIoS7VzH56/KqPRfBGA/GyM9GM9uCScffbZpmlNElpzjIKjZRmHb+XCtLB/qZNAW2NN4ZhjjvnLtmyiK2mdcvkP2j3FYv2EhPbvOeec45zz2/Pskz59+uS3YXlAMxwhhBBB0IAjhBAiCHn3EXw2GqOqaNF8+umnplknrWfPnqZp0y1dutT0pEmTnHPOtW3b1rYxMos1iZiEyORFJlmxHhfP40uCrEp8SXpff/117Pa00UI33HBDxn223HJL01xNMoqGYql0Rkjlymb517/+ZZrLWdCm/eqrr2Lf67MkqzPRkhtMsPYlbSe5z/m8iuQ888wzppmEHsf8+fNNF2OtO81whBBCBCH1DCdXJVv4wz7/Aj399NNNc51uzlr413M0q3HOuVmzZjnnKgYYsOIzZzL8i+2VV14x/eWXX5pm/gYDBdIuNheCtP3iqyLN68yqs7ymBx98sGle/6eeeir2mNFfbTNmzLBtHTp0yNhGHwwE4ayKs1CW+jjttNNMM89qTfwBm/3C5yvu33OVV5bNd0ahPF+5hp+Lbkuma77DDjuY5ncYn6eoOrtzFfMHzzjjjMo1NodohiOEECIIGnCEEEIEIbWllmRKnGQKzekgf9hnLP+///1v082aNTPNH3h33XVX09EP0fyxn0ELL774oulRo0aZ3m677UzTgmOJGP6Amk1eQdr8kKRkY2/yvQzmmDp1qmm2+7HHHot9L3WcNXP99dfbNva5D+bGsM8ZIPHSSy/FtpF5Rqy8W5XlhwoBX1BA3L/nysLK5t6sTjYaiapCO1cxgCb6eYGfe8CAAabnzZsXezxfMMyZZ56ZVTvj4E8gadEMRwghRBA04AghhAhCXvJwOIVm5WZWH6ZdQrvs9ttvj9ULFy40zZI3LLkSLao2fvx428ZoJZ9dwOPRiuG0l/ksXKSNsfC0CX02QgiLIElkj28fLoDGz8P+8n22THbhnXfeabp169amaQfwPLxfyLfffht7TloTtIseeeQR04cccshq27gmEfUvozdpdYa0swplwcJQ0JZi1GV0HWijDR06NOPxfM8K+5alrbIhbVksohmOEEKIIGjAEUIIEYS8l7bhVI/2B6d6H330kenXX3/dNCPJOM1euXKlaSY2RUmbNWvWtG3UjG5ihVYee8cddzTNBCrCSDbaDoViBSSxQlhCg1ZU7dq1TbOcDZNj2V9777236bvvvts0LZKmTZs65ypeHyaqvfXWW6Yvuugi0yxPw76LEnydq5ioyrZHZVucc+7EE080fdJJJ5lu37696bPOOsutCdBqjCvn89lnn4VsjlEoz04+mTlzpmn+jMDvwug63HfffbYtm7JLubLRcoVmOEIIIYKgAUcIIUQQ8mKp+SJOqGmR0Gq74oorTNMioe3DhdE+/PBD05FNxiko7SWeh1Ybo0Q4BeU+tNGSJC0WOnHr2Tvn3P7772/6/PPPj92Htgxtz+uuu840rdQFCxY45yr2/wUXXGCaVaRvu+020z6bhfvQ9nv//fdNd+zYMfY4jJQja0r0Gp8HXveIfv36ZTwGI6x8EUt8pliTb02D3yGMAC0rKzPNaNCof6rrNdMMRwghRBA04AghhAhC3hM/fdtpuzFijFYPrSvaaLTGOB2N9uF0vnPnzqa59MDf//5302PHjjXNBeAYDedb2qAQF2PLJonOl2QWrbXunHM33nijaVqjL7zwgukoMs25P5J/eT27dOlimomc++67r2kud0BrYsiQIbHn79Spk+kaNWrEfg5ffbY1ZQE2RifGJepOnDgx4zG4tIiP6moJpYX359Zbb22azyj7IUpUT5Kwzb5knxRyxJ9mOEIIIYKgAUcIIUQQ8p742atXL9NcYfDCCy80zWknp4O01DgF9SVbRvvQNmEi54QJE0zvvvvuptu0aWOaSyL4aqMVesn0JLXO0n4GLi3gO+aYMWNMMwJq0KBBzjnnjj/++Ng2MqmUSyIQrhb66quvmqZNwT5dsmSJ6U022cS0L8Lw8ccfj91e3eDnj+5vRh02adLENFe5JWuC/chrwnqQrKnog/Y7awYy6pbwu+3jjz92zlV8Png87ltoSZ1J0AxHCCFEEDTgCCGECELOLDXWpZo2bZpprr752muvmaZFM3DgQNNMPGzVqpVp2iKst8XotchKO+GEE2wbVwSlXcap6dKlS023a9fO9KRJk0z7ItMKJSLE1yZeQ9ZyyhW01EaPHh27T1R77eijj7ZtTNjt3r27aS73wMi0iy++2PQZZ5xhmktFcHVXRtUVa6JuPu6zuJVYyeGHH2568ODBOTlnMcLnnTZakj6pV6+eaUZmJlntN0pe5r609/bcc0/T/M5lXxXKd1IcmuEIIYQIggYcIYQQQciZpUYbjbRs2dI066RxJc6nn37a9A477GCalgqnsrRUOPWNNPfldJRTzWeffdb0yJEjTXP1z0Kemv4ZX1tzZaP5ItySRCxFK3oOHz7cttWvX980bQJapLQ377jjDtPs83322cc0E3ivvPJK07TpaHcUOvm4/+LsRZ6HzxZr4xXTs5BPklwHWnB16tSJ3ccXARtZx/x3JsZz2Q1+bxZ65GyEZjhCCCGCoAFHCCFEEPKe+MlVM4888kjTnDKy9hlX/GzevLlpWmM+HcHp5bx580wvWrTI9OTJk03TXivGZKrV0aNHD9PsCy4fkARaWieffLLpJFP5aHmCYcOG2TZaZ7R5eP2ZBMqVPVl7jTWknnvuOdO0AGmjFWKEYVURXWvWnfM9l0zOZuQVYW0v7r8mw+RZWr6MnmXUbdx1Y33J2bNn57iFYdEMRwghRBA04AghhAhC3i01WiQ+u2r+/Pmmmah4+eWXm2YyJ6fujHaKytmzTD2TCpng6SsP7qPQrRhfFNmbb76Zk+OfeOKJWbeHdunDDz9smgmhrDdF64a11AhXnyQ+q68Q+66qiCyz/v3727bevXubpnWNAn8oAAAgAElEQVSZBNpB2Twvffr0Mc0I0mKH15Y/BTCBs7qjGY4QQoggaMARQggRhJI0092uXbuWT5kyJScn9tlYaROYWrRoYZoRaRGFbKGUl5e7kpKSKeXl5V2zOU7Xrl3L33333QrHzTWMXoqLDPwzjDCM65ds2GWXXUxzqYK0+GyfXPRL165dyydPnhxbr6zY8dmeAcjJs5Kr7zCR/lnRDEcIIUQQNOAIIYQIQs6i1HzWgc/eSWud+eyPuXPnJj4GVwL11TIqVuJWPv3zdsJrkaQeGi1QJgpGSw84V3Hl1FzbaMRno6Vd0bQ69Hs2RNcr7bPos9HSRqYVeuSnyD2a4QghhAiCBhwhhBBByJmllmRKzFLdK1asyPnxM0HroDpP4ZPYa0lsNEK7isehjZYGX3Lfuuuua5o11pJYtsVSor1QyPX1SvtMVednUMSjGY4QQoggaMARQggRhFSJnyUlJUucc3My7ijS0LK8vLxRNgdQv+SFrPpFfZIX9KwUJon7JdWAI4QQQlQWWWpCCCGCoAFHCCFEEDTgCCGECIIGHCGEEEHQgCOEECIIGnCEEEIEQQOOEEKIIGjAEUIIEQQNOEIIIYKgAUcIIUQQNOAIIYQIggYcIYQQQdCAI4QQIggacIQQQoShvLw88au0tLTcOadXjl5dunQpd84tSdMH6pfi6JfS0tLoOHrl7lUUz8q6665rrwK4Znl9pX1WUs1wysrKEu1XUlJir7Rk895iY/Lkyc7lYDGopP0ikpGLfikrK4uOI3JHUTwrDRs2tFdaiu27L+2zIktNCCFEENbJx0GzWUVUK5AKIYqZBQsWVPq9ufj+W3/99U3/+OOPWR/vz6y99tqVfq9mOEIIIYKgAUcIIUQQ8mKpFRvrrPPHZfj111+rsCVCiEKmTp06plesWFGFLfGTDxuN/P7775V+r2Y4QgghgqABRwghRBDyYqkVg0V12mmnmf7vf/9bhS0JR76jV4So7uTjuVlrrT/+7j///POdc85deumltm299dYzfdhhh5kePny46Zo1a5pmpFvt2rVNr1y5MiftzSaSTjMcIYQQQdCAI4QQIgh5sdQKyUbbcMMNTX/77bemb7vtNtMsJcGp6Q8//JDn1oUlH3YA7VNy4YUXmh49erRzzrmWLVvatq+++sr05Zdfbvof//iH6Z9//tn0qlWrsm+sEFmS5LuNiZGM6KIVNXHiRNO9evUyve+++zrnnJsz549qMb6oMB6PEXM1atQwze+zbMiVHa8ZjhBCiCBowBFCCBGEap/42bNnT9P333+/aU47OTXt3Lmz6e+//970/PnzK90GWnbFWiuOES79+/c3fdRRR5nu0qWL6fr165u+7LLLVnts2hRLliwx3aJFC9PZWGrV4fpXBbpulaN58+am586da/q+++4zPXv2bNPfffed6fbt2zvnnOvevbtte+CBB0yzT6hr1aoV25bFixeb5s8LacmVHa8ZjhBCiCBowBFCCBGEammp/e9//zPNqCcmWPkWOTr33HNN9+vXLyftqQ52BBPIGIXz8ssvm+a1O+mkk0xH153XnzDS7bfffjM9cuRI07vssktlmu2cqx7Xv6phH91xxx2maQ2NGDHCNKOsipFOnTqZnjp1aqr38pqQo48+2jSfhXr16pmO7LWZM2faNiZ4rrvuuhnPz/u9QYMGmRscEM1whBBCBEEDjhBCiCAUvaXGqWkUScUkpSTQxjnkkENMR3WNnKuYBJpNee5igrajL5ntvPPOM/3GG2+YHjVqlOkoOpDWAaf9G2ywQex5vvnmG9PFUJ+vKvDZxA0bNjS9aNGiSh2bdkzfvn1NH3rooaZpte62226mzzjjDNPTp083XSzJ1GlttLTwGWKUWvTdtf3229u2JCtsDho0yPSAAQNM855g4jXvm1mzZiVtdtZohiOEECIIGnCEEEIEoSgtNU4TGQ3FMt5x0DqjZuTHq6++anrbbbc1/dRTT1WusUUMbS+fjcVlHnyUlZU55yomp/HYBx54oOkHH3zQ9J577mnaF+G2pkB7i9fr9ttvN837v7S0NOMxI6umR48etm3y5Mmmec1pl3LVSz6LO+20k+kTTjjB9Nlnn52xLSEpZHs2+l5i4mefPn1MX3/99ab//e9/mx4yZIhpX3LoZ599FntO2qL8XswHa/ZTLIQQIhgacIQQQgShKC01Rjtxtc64ZM6vv/7a9C+//GJ68803N33OOeeYHjZsmGnWT1Py4B/QguQ19RFdO0ZOcXmCa6+91vRPP/1kmstJNG3a1HTIqJqqhNGW/My0tBjBxHvUV/uqbt26pu+55x7nnHP77LOPbeNKk7z+7Dtf0jTP37t3b9O5SqDOFYVmo5FtttnGOVexfhproL3wwgumH3vsMdO0XLn0Ci0yPlu8t/JtoxHNcIQQQgRBA44QQoggFI2lxoiZp59+2jSn8dFUn3YCy+dPmjTJNPe56667TDPShpFpxZKwFoIkNhqJbJ9ly5bZNkbYNGnS5C/7OlexltqXX36Zup3FwhdffGE6Kk/vXMUVTxlJxCirhQsXmqbt6EtO5sqQ0f09fvx42/bhhx+aZoKnr11c5oNW2+effx57/mLhuuuuM81EynzA6zZhwgTnXMWlUWih0v765z//afrdd981Tfv11ltvNc1INkYRhkQzHCGEEEHQgCOEECIIRWOpvfbaa6aZFMXpaGQvzJgxw7Ztsskmppmk2Lp1a9PdunUzTXuBK05yii0y07hxY9ORffnEE0/YtrZt28a+j1Ynlz5Ia+MVE4yYZASgb1VI2mus95ekxh8t6CjJlteWzxOtPtZG23XXXWOPzchD1lUrRvJtoxHanJFdmiRxl33JvqIdd9BBB8XuzyVcomjFEGiGI4QQIggacIQQQgSh4Cw1RiltueWWphklw+ljmzZtTNevX98559ySJUts27HHHms6SqpyrmKkD3WjRo1Md+jQwTSj5NaU5QnSwogl1qRj38VBG4198fbbb+ewdYWLr04cLV1G6dFuYaJyWjLZlAsWLDB9wAEHxO5DG402aSE/I/yOyVXSI63IJEniAwcONM0ag5U959ChQ003a9bMNKMYabX5+jPfaIYjhBAiCBpwhBBCBKHgLDVOE++8807TjNJh9E6rVq1MR1FQtMKi0vjOVbR8aGPQxmHNqCOOOML0LbfckvgzFDM+a4DbV61aZZrXkRFWaWC/MKlw7733Ns1lC6obtJ+omYTMpM5PP/3UdForJxM8BvuTNh77aPfddzcdrbhb6OSjdpjv2vP5oNXP+mi5gCsV0+a88MILTSdZOTTfaIYjhBAiCAU3w+EiUiyt0a5dO9M33HCD6eHDh5uO1k7/29/+Ztv41/PixYtNb7zxxqb51wn/wrz55ptNrykzHN9faldeeaVpXzmTysK/AlnFljNc5uSw6i1nvtWN119/3XSvXr1MMyAjnzDfZoMNNjDNZ4R/TRcjvN98FbYJqzL77j1Wx6YbkGRWEwVypHULTjnlFNMsbcPjzJkzJ9UxSa4CLTTDEUIIEQQNOEIIIYJQcJYap6Ccxkd2mXMV17pnHs5ZZ53lnKu4QBunlDwe49NZ/oZ2Aa25XOHLuShE9tprL9O0Lvv372+a13r58uWmmVsQZxMk+QGTx7jssstMs0QRYf9y8bBigp+Z92XLli1Ns3owLdBc/GjPPnr44YdNM7CGz8iIESNMV1VuRzYksdFoIfG+jfL+nKu40CP7gQvesa+23npr0x988MFfzkmrmiWh9t9//9g28nNsttlmpseMGWOaC+3x2X7uuedij0lyFWhRPN9+QgghihoNOEIIIYJQcJYap+tTp041TSvKV0Ll8ccfd85VnP5Rv/XWW7H6iiuuMM0cg1xEYP2ZQi758WdeeeUV07wujNRhKaClS5ea5ueMrAfaMvPmzTNds2bN2PNz0TuWAuG9wP4tVhuN8DPvuOOOplnChlZO8+bNTdPuufrqq01vtdVWpmmHRotz0fZhX/iiN1kSh7lq1QleE0ayMdKV9z6hzczrxir3cTYa4bXn+Xk8PgennnqqaUbUslo0o+pYfT8JtHSziXbTDEcIIUQQNOAIIYQIQsFZaoTTR1onv/76q+mNNtrIdGQp0Bbg9J+RIYyooV1EclEqpJhJcl1oMfiIqtTSomQlYla3ZZQUj3300Ueb5jrt1Y0mTZqY5qJntJHvu+8+0yzFxGimadOmmb7qqqti3xs9L7zmtGl8EXB8FvfYYw/TkaVd6DDK9fnnn4/dhxGXfA7SJmTyWrE8E68bLaromtNGY1t8/cNniFYf+42RdPwOTQLb6LPAk6AZjhBCiCBowBFCCBGEorHUfHTr1s00p6ERjIy6/PLLTTMaSMTTunVr01wAjMm5aWBS47Jly0x/8803phs3bmya0TYTJkyIPU5160fWJmNS5V133WWa9zmjjXhdaLcwko22JusWRvCZ4760clasWGGadbuKBZ+Nxu8KWk7ZVFmmBccoSlqetP2jPuS1TxIt+/TTT5vm9xyj7V544QXTvXv3Ns0E3yRU9vl3TjMcIYQQgdCAI4QQIggFZ6n5FpTilJ7JTKNHj17t8XgMRuiIzDA5k9FTtFGSRPJFfcpp/6abbmqatcHY/7RuPv/8c9O00fKxPn2hcOONN8Zu99X/YvQQa89dfPHFprkgV48ePZxzzo0aNcq2sZ99x+azSHuKNe5Yw6tY8EVu8fuGkYBJ4PPBJVFoZ8b9FOBb/JDb2V5a3kwwHTdunOm7777bdFVZoZrhCCGECIIGHCGEEEEoOEuNU0baJYyYeuSRRxIfj6sWVodaW9ngi8LxQauF15F2ze23327aVx5/xowZzjnnWrRoYdtoE7AtPAYjsHzRaDkrm14gy0aUlpaaZqJeEngdL7roooz7v/HGG865ivXQaMEwepC25z//+U/TXLaCltHZZ59tesiQIRnbUlW0atXK9MyZM037lgdIC4/D+z8TPkuN0Z2saUgYAedbeqWqKIynTAghRLVHA44QQogg5N1S43SQFlkSS4d2yUcffZT4nIyQSVuGuzqT5Jp37tzZNG0UTse5nMPxxx9v+vTTTzd9zz33mI6SOdn/tAy4rEGHDh1MRzXYkkJbLK19UAh2g3PpbbRcwKU6evXqZZrP39tvv236ggsuMH3KKaeYZqKqj7S2br6hjearU8aIsvnz55tmHTsfvvuc9mPTpk1Nt2vXzjnn3FFHHWXbevbsaTrtkimFcl9HaIYjhBAiCBpwhBBCBCHvlpovUYnJTr5ENk5xk9QziqJqDj744NTtzDVJPl8hwpUIaa/4ks/at29v+sUXX4w9ZrT/Tz/9ZNtoufXr18+0r5ZXkgRTn32Q9jhrGr7VPGmj+SxVksTSLAQbzYevzbwmtNG4giZrpnE5A35vDRo0yDTvQyZYR9r3LBU7muEIIYQIggYcIYQQQQgapcZpZBKb6frrr8+4DyNstt9++5Styx+FaKOltZbq1atnmhFjvmgeQvssWgnynHPOsW2M9vHhOzaT2dguJoey9lc25dTXBJj8+OGHH5ou1ki/XOCzxLmyJq17LgMwePBg03zmfCvorklohiOEECIIGnCEEEIEIWiUWlq4UiHh1JSRVMVA2sStXJK2L1jXLEmUYK5XCCVz5swx3bJly4z7VwcbLVR03cKFC02nXUGV9iqTOovFPvIlovoscVrBQ4cOzV/Dqima4QghhAiCBhwhhBBBKLjlCcg777xjevz48ab/+9//mi62RL5iam/atnJVzlyTxEarboS6V2rXrm3aZ6n52sLItGKx0UghJ6JWRzTDEUIIEQQNOEIIIYJQcJYaI3Ouu+4608VkRYlw1KhRw3QhWjrZrOAZisWLF5tmwmyS5OXly5ebZvKjKH7yESWpGY4QQoggaMARQggRhIKz1GSdFT5cCXTFihVV2JLCtNFIodpoPtImzK5pNlo2q8oWG/n4LtYMRwghRBA04AghhAhCSZppU0lJyRLn3JyMO4o0tCwvL2+UzQHUL3khq35Rn+QFPSuFSeJ+STXgCCGEEJVFlpoQQoggaMARQggRBA04QgghgqABRwghRBA04AghhAiCBhwhhBBB0IAjhBAiCBpwhBBCBEEDjhBCiCBowBFCCBEEDThCCCGCoAFHCCFEEDTgCCGECIIGHCGEEEHQgCOEECII66TZuWHDhuVco72kpMQ019XhOuc//PCD6d9++61SjXSu4lriPFdpaanppUuXOuecW2edPz7Wr7/+arp27dqmV65cmer8vvc2bNjwL+dPSpcuXdyUKVOWZruoVMOGDcu/++47+3/fdV533XVN//LLL9mcMmvWW2890z/99FOw89aoUcP0zz//bJr38jbbbJN1vzRs2LC8rKzMTZkypbKHqBLWXntt09k8r3kiJ88Kv8NEdqT9Dks14JSVlTl21vrrr2961apVprfddlvTH3zwgWl+Kf7++++mOYD4BrGaNWua5pfl3//+d9N33323c865Bg0a2DYOAh07djQ9efLk2Lbw/NzeuXNn0xMnTjTdu3dv0/fee29s23kcPtCTJ092JSUlWa8+WFZW5mbNmmX//+2338a2Y6ONNjI9f/58075rTnyDeBKi4/PYLVu2ND19+vRUx4s79p+Pz+1k4403Nj137lzT/Hy56JeysrLoOLH/zu2+ey5Jv+SaevXqmebzmu/z8w9KXoM/kZNnpdgGnKq4D5KS9llJNeA4V/HG4CDDi/L666+b5peT7wuBA1ffvn1NDxs2zDRnFXzvAw888Je2nXfeebZtwIABpt977z3T/Guff8mNHj3a9JNPPhnbrn333dd0NMg5V3GgW758uYsjXzfM999/n/EcHGTSton9mOTLIdNDknaQadWqlemZM2eu9th/Pj/byEGGhJ7xsd2+z5CkX5J8GaWZ2XKQSQKf3R9//DHVe8lqBpmc06RJE9NfffVVsPNWlkIYZHI16Ok3HCGEEEHQgCOEECIIqS01/pZCm4vTLFpUnIptvvnmpvmbA380vuuuu0zTuiE8V9yP/7TUGMBAm4vton9/9NFHm2bAA3+f8XHAAQeYfvDBB03zd5t8WQe+a+6zPHyWUxJ8vzNkc8xM0EZLQpLz896gPVwoJLExfNsZTEO7NRMM5uA9xe0HHnigad99niTgYNNNNzXN74N8Uww2WqGRK1tPMxwhhBBB0IAjhBAiCKktNZ+d4guR5j4LFiwwzagnWlqElhpzJtK00Wej+eyfDTfc0PSKFStij7/nnnuafv75500zYs5nceULn0XIa+jLJaJF8sQTT8Qe0zelpo3iC5c+/fTTnXPODR061Lb5IqfykQfi+xw+S7hQYA5Pjx49TNMabd68uWmmANAOJnH2Lq8PLXM+CzNmzDDN59tnpSfBZ6MVchiwyA7NcIQQQgRBA44QQoggpLbUOJ2mdcNIM07bqTnN53u7d+9u+rPPPjPtKxVDmyiu5E3jxo1tG7Prp06dappRN/Xr1zd96KGHmh4yZIhpTvPff//92Hb5YBt8Vke20HqgRUXtsypoo5EWLVqYnjMnPpk4SdUBWmlx78umikESktiB+Ur89NlVSe6DbbbZJuM+8+bNS9UePi+RHXfllVfaNibG3n777aZpgY4ZMybVOdNaZLLRqi+a4QghhAiCBhwhhBBBSG2pkZ49e5qmzUQrjNFrnCo3a9bM9KRJk0xzyk+rhUmjm2yyiWlG70SFQrkvC1n269cv9nhffvmlaRaVpM3CmmnffPONaRaDXLZsmWlGEjFSLl+WGm2LXXbZxfRrr71mOq1d5bPRfLDv3nnnHdOnnXaac67iZ/dZQWyjL0rQV/E5LSHqp/Ge5+dPGwHoq72W1n5iROaSJUuccxVtZD5ztNSyuVZp26goteqLZjhCCCGCoAFHCCFEELJanoDJYIxSu+CCC0yPGjXqj5Nhus6p8n/+85/Y9zKSjEmjW221lelDDjnE9DHHHOOcqxhRQ4tm7Nixpmmj7bXXXqZp12y22Wamjz32WNNcnoD2GhPfaF0wOilf8Hq+++67prOJ+kpr+7AOHcvc16pVyznnXKdOnWxbZLM5V9EWveOOO0zTmh03blzsOXlfFDppk1r5rPksrbT2E48ZLR7oSxROU4Mtl6xpNhoTbHfbbTfnnHMvv/yybevQoYPpRYsWmc5mHamqQjMcIYQQQdCAI4QQIghZ1VJjFBPtgmuvvdY0bZYRI0bE7v/KK6+Yph3WunVr00wOvemmm2LbE9kLtBk4Be3Vq5fpp59+2vTNN99seocddjBNS+eqq64y/fHHH5vmdDiJNZGPxMY/k3bVRl/UVxJro0+fPqb3339/04w83GeffZxzFa0+RqCxxtugQYNMT5s2zTSTUG+44YaM7SpEfDaa7/rTRotLcP6z9sHngTZ1FIXG+5b7nnTSSaaZBC0qBxPAFy5caDpNrUX2N5dZYE29QrYkNcMRQggRBA04QgghgpBV4mcUfeRcxVLvxx9/vGmulLn33nubZjTaTjvtZJorFV5//fWm27dvb5rJpLQg3nvvPeecc6+++qpte+yxx0zTlmHC5kcffRT7OWj1HHHEEaa32GIL00kiiWj70TIsFLJJnnzooYdMM8mUdmSUBMtrNWHCBNO0KPv372+aUW1RRJVzFSPZmFSbDbw3QtCxY0fTvP98pF1BlTYN7Wtuv/TSS51zFZfb4L68V/ORjFnsCZ5JagDynn/99ddNV3bJEr6vadOmpnfddVfTL730UqWOHQLNcIQQQgRBA44QQoggpLbUfJYQp3rDhg0zfcopp5j+3//+Z/rtt982TWuOU8O2bduaZmIp7ZqBAweafuqpp5xzFa0tvo+RUVwG4euvvzbNyA8S1WlzzrlrrrnGNJc2YBKoj3zV72KkE6f3aa2YJNAm4PF5reOi3Ro0aGDbmMzGqENG2NGyqFevnul81KNjInAIkthoaeE9wPuM9wP1F198sdrjpY1YTEsx2mjEZ6Pxu9AXaegj7pqMHDnSNKNCadFdccUVphmxxp80CgHNcIQQQgRBA44QQoggpLbUOEWknbL11lubpl3FEucbbLCB6YMOOsg0lyo499xzTdPmmDJlimmuOEgd2X1MsGNiJqe0rG+2ePFi01zR9OCDDzY9a9Ys0wMGDDA9f/5807QMCaPdGAWXS5JEmnXr1s00Lc20+OrEcSkIWgNRROCmm25q2+677z7TdevWjdW06M455xzTSeqQJYFtZ78XK7wuSeyqyA72RUzx3q6qiLKqOm82S2C0atXKNG03HpPwc0XfFb77MUqidq5idC+/l7lSrCw1IYQQayQacIQQQgQhtaXmS3biCo6MBmOCZbTCoHMVp6mMTGPtMx6HUT1MGoxbioBJfKwdxQg0TkE5baflRQvqxRdfNM1oNE6HeZzGjRub3mOPPUzff//9LiRsUzY2mu+YtAm4bMPJJ59s+p577nHOOXfmmWfaNlqdtOhYd47Rg4x8TNtGnxVTKDZaNrYRbeIkVmPcPcptviU2cmVnMaozyfIHVRXJlk0yNL9nuPTK5ZdfbprX9owzzjAdd0+yfz755BPT/G6ljedbTbcQ0AxHCCFEEDTgCCGECEJqS43TO9prvpL43H/w4MGxmpYTkz0Jo5pozXFqGtWBohXHelxRTa8/H8NX7p1tYSQdLUBG8tDKmzt3bmzbaSnkEl8yJmtj0QJlzTpaVz5Yv47HP//8800zyZfWZGSp+aKhaK0wYpDJbGlJa8X4IoiyJYldlo1txH6n9iUl8lzRchJxS3w4VzHZOQm+lXZ5zqpaRTQk/J5h3T8+Ky+88ILpW265ZbXHO+GEE0yzpuPnn38eu3/a5UlCohmOEEKIIGjAEUIIEYSslidIYgUw2bNr166mjzrqKNPbbrutaVpUtMZYipsWEJMDo5psm2++eey/d+nSxfQbb7xhmhFTtPdoL9Au2H333U0/8MADpmnT0bJi4me+IqN8NdN81orPRvPZXqx3xkjC/fbbzzQjAmkdxt0n7Be2ndGAY8eOjW1LNvjK9mcTlbQ68h1lxf5t06aN6enTp2d8b5QUyHqEjN489dRTTZ999tkZj5ekTqDPYvRZwsW+hEHfvn1N8zshUz1AWthDhw41zUhT2sC8Nr4o3nzVcUyDZjhCCCGCkFVpG84MGEDAH37nzJljmrMKzl4+/fRT04wn9/0VzMrBHMGjRbr4Yz//ImCV6c022yz2nNttt53pdu3amb755ptj2+KbsXD7xRdfbPqss86K3T9bfH+5E99sh/AvJR6Hffp///d/prl4Ghfe23LLLU1H/cvF1ZhDwCCMiRMnmuaiawxCYLvSlrnh50tyPQod9jvvb/6FzOeI165fv37OuYrPLv+d5arS5s+QbEo7MRCH3yXZQFeCTks2+IKpuIhkmuOwbA375G9/+1vGY9DJ4bUvhGACzXCEEEIEQQOOEEKIIGQVNMCpOsu98AfAk046yTQrlz7//POmOUV/+eWXTbNaNPNp+IMo7a1oUS8uLMV28Ud9Wl7t27c3zQAG/rC38847m2Z5CQYo+Ba0Yj4JFyHLJUmsorQ/wHKfQYMGmaYt8vDDD5t+6KGHEp+LFcWXL19umsEMtCZIPhaVY3BLLmF/58PS4DXyLbrG68/Ajjh7hteWz2KSa+6zOpPYaL77MVc2GsmVjUYOPfRQ008//bRpWpuE9zx/Fthiiy2ccxUXefQteumDVmg+7rlsnj/NcIQQQgRBA44QQoggpLbUmjRpYppVUWmhUNN24xQ9yplxruLCZVwU65VXXjHNaCiWjqB9F5WL4L9z6sqp4LJly0w/9dRTpvfee2/TnA4zko6LynFhNn4mWgqM8GG0Vy7hNWe7aR2mzWPg9WJUYZI2ZDoXI9AY0caSH7Nnz459ry/qKZs8DS4el0vyYWn4njVeC18+FZ/HqDRKZOM45690nLDKpXQAAAgqSURBVOTa+qyWJPcFn5FCiKZKy+jRo03zO5L2O6Nria/ifGWhzZ+WJBGg/M5NXd28cs0SQggh0qEBRwghRBBSW2oLFiwwzekfo18YIdOnTx/TnK7RonrmmWdMM0qMlgqtAB9RtBv39U352PbWrVub3mijjUwzem3q1KmmmWDHhcGOOeaY2PPSdksbcZIU2mg+yyUfpUF8CaeZkiofe+wx07QaxowZk/GcSey96gwtjWxK8owYMcI551zv3r1t26RJk0z77hef7ZLk/mJUHd9bjDYa4Wf3/dTgg/tEz42vCniS8zMaNy1pE6nTohmOEEKIIGjAEUIIEYTUlpovooKRYUyCYvVl1i9jZNJWW21lmomEnH6niZJJsi8jnVjjixWtaR0cd9xxpm+99VbTAwYM+Mv5/0waq6mycNqdqRJtLklTm2zTTTc1zcgoVginXSniycb24Hujmni0w2l1E18UpC+p87DDDjPNZzrt/V+M1aLZTtrFjF479thjTXMBtk022cQ5VzEpl//us+R5Hkb65qs6fWXRDEcIIUQQNOAIIYQIQla11GjjcKrOCCROAcePH2+aiztxmh1NKZ1zbsaMGRnbQBsrqiXlS0yidXDIIYeYPvDAA/9yDOecmzdvnmlOUxmZxjLitBrYrnxHfjiXvux7WnwLZCUhsim59ACPx5p5Ir/weWzZsqVzrqJtNW3atNj38TmifU54HNpo2VAsNloSfEm1JIq0pbXJOoa+Woy8TqwfmQ38PvP1eVo0wxFCCBEEDThCCCGCkNpS47SZ9Y9oGzGRjOtuc6rXsWPH2PfSruEUlPv4LKpoWsk2MnqDSZ3dunUz/d5775lm9BSXJGCECaPOWJPNZzU1bdrUNCOyckndunVNs35cNqtjkrQ2Gi3IqIaeL+qQycEiv/hWg41o06ZNxmP47qNcRZQVY2RarmE/8KcAPoeMRs2HpZ4rG41ohiOEECIIGnCEEEIEIStLjTWtWHfswQcfNL3vvvua7ty5s+kJEyaYbtasmWlOH/v162eaNbY41eMUM7ILaOPx/Oeee27seWj/MEqHNdkYNcIIK19dL+5Da5DWVy6hjUZ4befOnWs6dVlxT+Sf7zhc6bVOnTp/+ff77rvPdFXV0Sp06yYf7eO9HlmcPDYTBdOeP1crsRZiX4Rm3LhxpvldleS7p5DRDEcIIUQQNOAIIYQIQlaWGkujc0VOTok5BWQ0WJcuXUwzcuvCCy80zeiuSy+91PSLL75omssZ7Lnnns65ismjzZs3N80pP+sTtWvXzjQjppiQys9Ki4iftbS01PTXX3/t4vBZX/nC1w4f7K8333zT9ODBg01zJVbaYYxCu+666/5yTF6r4cOHm86mxH4SGPHDZOIQCbnZkA9rifdf9Pl5HkaeytoKT/QMMaLWtzxB9+7d89qWTp06mebyLNmgGY4QQoggaMARQggRhKyWJyC0q2i73XvvvaZ333332PfuuOOOpmlzXHzxxaZpe7H0eaNGjUxHU0/WAHrrrbdijx3VkXKuYl01XxIqSVL+37diHxNRQ8CIPvYdo5V8Swzstttupmkj7r333qZpr7HGXFyC4ZQpU0y/+uqridqfC6ZPnx67PVdJscUE+zeq28XISa4Wmfb6rInXM9dE/eOLBOXzzCheRuDmilzZaEQzHCGEEEHQgCOEECIIqS012kwbbrihadZJo6VGy4ul/wmnbnzvRRddZJpRbVxRdJtttjEdRTuVlZXZtieeeML0zTffbJq22Jlnnmn6hhtuiG0jI7CIr7YRp8EsCR/ZGKGghUJrj5FhPvuDSYBMMuMyA9Gqkc5V7CP2dZRw2rdvX9sWMgLKtwJiw4YNTS9evDhYe5zLv/3kS9qkjpblGDJkiG2jHe2LNuWxfctw1KpVy3TaFWgZheqz4asrkXXN7xt+Z/C5zYeNlm80wxFCCBEEDThCCCGCUJLG2ujatWs5rQfaJtzOaTbtJE7FfVYPt/O9PCZ1lOzp3B9WGuueTZo0yTTtFB9JVrZkrTZeP18beUx+plWrVrmSkpIp5eXlXTM2bDV07dq1nBFgxLdqXzZ1umiXcJkJ2qeMaotWf8zGRvMlvyWp65b2+L/99lvW/dK1a9fyyZMnV7jO2bQpSZ2yJDYW7ebIJuUSG3z+fOfkMWbPnp2qvdmsHOucy+uzUghEVuuzzz5r23bddVfT/OmCzxth0mi+reLy8vJUz4pmOEIIIYKgAUcIIUQQUkepse4Zp8ScxhFfLS9fsiGhZcfj0y5g4mHUHkbLMNGSU9NnnnnmL+9zznktENZJ47SWMPKIUSb8HPlKiKOFlaRseTb2E6//O++8Y7pt27amaWvmgmxK3/vsOJ8FWigkaRPvV5+NxvuSFljjxo2dc+lr2fEYvrb4tvMz+exeko9oviTnrSqiz7jHHntU+hhM3i00NMMRQggRBA04QgghgpCzWmq0U1jWntPgkSNHmmYSoG+qzKgbWnO+yDAm+EWwHDtX0atdu7bplStXmmaNtTlz5sSen/gi7HyJcly9L5f4bDSeLxvbgvvstNNOprlyK69XrvHZNSFXosyWfNhDST6/71yLFi1a7fvSRpT5zuNrYxI7Kx8WdCHYaPlcbbaQl5XQDEcIIUQQNOAIIYQIQqrEz5KSkiXOufz5JmsmLcvLy+MzuBKifskLWfWL+iQv6FkpTBL3S6oBRwghhKgsstSEEEIEQQOOEEKIIGjAEUIIEQQNOEIIIYKgAUcIIUQQNOAIIYQIggYcIYQQQdCAI4QQIggacIQQQgTh/wMwC6M8yrM1WwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0ed71710>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "saver = tf.train.Saver(var_list=g_vars)\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, tf.train.latest_checkpoint('checkpoints'))\n",
    "    sample_z = np.random.uniform(-1, 1, size=(16, z_size))\n",
    "    gen_samples = sess.run(\n",
    "                   generator(input_z, input_size, reuse=True),\n",
    "                   feed_dict={input_z: sample_z})\n",
    "_ = view_samples(0, [gen_samples])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
